// 学生档案完整录入及编辑修改模块（配置驱动架构）

// 🔧 全局变量声明
let queryFieldsConfig = null;
let studentConfigManager = null;

// 🔧 学生档案状态管理全局变量
let selectedStudent = null;
let currentMode = "readonly";
let isNewRecord = false;
let currentQueryParams = null; // 保存当前查询参数，用于恢复后刷新查询结果

// 🔧 新增：引入学生信息条组件和QueryResultTable组件
let globalFieldConfig = null;

/**
 * 加载学生档案配置（统一配置驱动架构）
 */
async function loadStudentConfig() {
  try {
    console.log("� 开始加载学生档案配置...");
    
    // 1. 获取全局字段配置
    const globalFieldResp = await fetch("/api/config/all_field_config");
    if (globalFieldResp.ok) {
      const globalFieldData = await globalFieldResp.json();
      if (globalFieldData.success) {
        globalFieldConfig = globalFieldData.config;
        console.log("✅ 全局字段配置加载成功:", globalFieldConfig);
      }
    } else {
      console.warn("⚠️ 全局字段配置接口不存在");
    }
    
    // 获取查询字段配置（使用统一的查询字段接口）
    const queryFieldsResp = await fetch("/api/config/query-fields");
    if (queryFieldsResp.ok) {
      const queryFieldsData = await queryFieldsResp.json();
      if (queryFieldsData.success) {
        queryFieldsConfig = queryFieldsData.fields;
        console.log("✅ 查询字段配置加载成功:", queryFieldsConfig);
        renderQueryArea();
      } else {
        console.error("❌ 查询字段配置加载失败:", queryFieldsData.error);
      }
    } else {
      console.error("❌ 查询字段配置接口调用失败");
    }
    
    // 获取学生档案完整配置
    const response = await fetch("/api/students/complete/config");
    const result = await response.json();
    if (result.success) {
      studentConfigManager = {
        config: result.data,  // 🔧 修复：使用result.data而不是result.config
        getFieldConfig(fieldName) {
          const basicFields = this.config.basic_fields || {};
          const extensionFields = this.config.extension_fields || {};
          return basicFields[fieldName] || extensionFields[fieldName] || null;
        },
        getModuleIntegration() {
          return this.config.module_integration || {};
        }
      };
      console.log("✅ 学生档案配置加载成功");
      return studentConfigManager;
    } else {
      console.error("❌ 学生档案配置加载失败:", result.error);
    }
  } catch (error) {
    console.error("❌ 配置加载异常:", error);
  }
}

// ✅ 使用FixedQueryArea渲染查询区（带自定义按钮）
function renderQueryArea() {
  console.log("🔧 renderQueryArea函数被调用");
  
  if (!queryFieldsConfig) {
    console.warn("⚠️ 查询配置未加载，跳过查询区渲染");
    return;
  }
  
  console.log("🔧 开始渲染配置驱动查询区:", queryFieldsConfig);
  
  // 检查FixedQueryArea组件是否加载
  if (typeof window.renderFixedQueryArea === 'function') {
    console.log("✅ FixedQueryArea组件已加载，开始渲染");
    
    // 添加新增按钮到查询区域
    const customButtons = [
      {
        text: "新增学生档案",
        className: "btn btn-success btn-sm",
        onclick: function() {
          createNewRecord();
        }
      }
    ];
    
    try {
    window.renderFixedQueryArea(
      queryFieldsConfig,
      "fixedQueryArea",
      onSearch,
      onClear,
      false, // 禁用列配置按钮
      customButtons // 传入自定义按钮
    );
      console.log("✅ FixedQueryArea渲染成功");
    } catch (error) {
      console.error("❌ FixedQueryArea渲染失败:", error);
      // 降级处理：显示简单的查询表单
      renderSimpleQueryForm();
    }
  } else {
    console.error("❌ FixedQueryArea.js 未正确加载");
    console.log("可用的全局函数:", Object.keys(window).filter(key => key.includes('Query')));
    // 降级处理：显示简单的查询表单
    renderSimpleQueryForm();
  }
}

// 🔧 新增：简单的查询表单（降级方案）
function renderSimpleQueryForm() {
  console.log("🔧 使用简单查询表单作为降级方案");
  
  const area = document.getElementById("fixedQueryArea");
  if (!area) {
    console.error("❌ 找不到fixedQueryArea容器");
    return;
  }
  
  area.innerHTML = `
    <div class="row mb-3">
      <div class="col-md-3">
        <input type="text" class="form-control" id="search-name" placeholder="姓名">
      </div>
      <div class="col-md-3">
        <input type="text" class="form-control" id="search-education-id" placeholder="教育ID号">
      </div>
      <div class="col-md-2">
        <button type="button" class="btn btn-primary" onclick="simpleSearch()">查询</button>
      </div>
      <div class="col-md-2">
        <button type="button" class="btn btn-warning" onclick="simpleClear()">清除</button>
      </div>
      <div class="col-md-2">
        <button type="button" class="btn btn-success" onclick="createNewRecord()">新增学生档案</button>
      </div>
    </div>
  `;
}

// 🔧 新增：简单查询函数（与其他模块保持一致）
function simpleSearch() {
  const name = document.getElementById("search-name").value.trim();
  const educationId = document.getElementById("search-education-id").value.trim();
  
  const params = {};
  if (name) params.name = name;
  if (educationId) params.education_id = educationId;
  
  console.log("🔍 简单查询参数:", params);
  onSearch(params);
}

// 🔧 新增：简单清除函数（与其他模块保持一致）
function simpleClear() {
  document.getElementById("search-name").value = "";
  document.getElementById("search-education-id").value = "";
  onClear();
}

// ✅新增：查询回调函数
function onSearch(queryParams) {
  console.log("🔍 执行查询:", queryParams);
  queryStudents(1, queryParams);
}

// ✅新增：学生档案查询函数（与其他模块保持一致）
function queryStudents(page = 1, queryParams = {}) {
  console.log("🔍 执行学生档案查询:", { page, queryParams });
  
  // 保存当前查询参数，用于恢复后刷新
  currentQueryParams = queryParams;
  
  // 构建查询参数
  const searchParams = new URLSearchParams();
  
  // 添加分页参数
  searchParams.set('page', page.toString());
  searchParams.set('per_page', '10');
  
  // 添加查询条件
  if (queryParams) {
    Object.keys(queryParams).forEach(key => {
      if (queryParams[key] && queryParams[key].toString().trim()) {
        searchParams.set(key, queryParams[key].toString().trim());
      }
    });
  }
  
  // 🔧 修复：使用QueryResultTable组件提供的字段配置（严格配置驱动）
  let queryColumns = window.getModuleQueryColumns('student_archive');
  
  // 如果配置为空，使用完整字段列表（包含所有用户需求字段）
  if (!queryColumns || queryColumns.length === 0) {
    console.log("⚠️ 查询字段配置为空，使用完整字段列表");
    queryColumns = ['id', 'education_id', 'school', 'grade', 'class_name', 'name', 'gender', 'age', 'id_card', 'parent_name'];
  }
  
  // 使用QueryResultTable组件提供的列配置（严格配置驱动）
  searchParams.set('columns', queryColumns.join(','));
  
  console.log("🔍 查询参数:", searchParams.toString());

  // 调用统一查询接口（与其他模块保持一致）
  fetch(`/api/students/query?${searchParams.toString()}`)
    .then((response) => {
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }
      return response.json();
    })
    .then((data) => {
      console.log(`✅ 查询成功，共 ${data.total} 条记录，当前第 ${data.page} 页`);
      if (data.success) {
        // 严格配置驱动：API响应数据完整性验证
        if (data.students === undefined || data.total === undefined || data.page === undefined || data.per_page === undefined) {
          throw new Error("配置驱动架构错误：API响应数据不完整，必须包含 students, total, page, per_page 字段");
        }
        
        const students = data.students;
        const total = data.total;
        const pageNum = data.page;
        const perPage = data.per_page;
        
        renderStudentTableWithComponent(students);
        renderPagination(total, pageNum, perPage);
      } else {
        console.error("❌ 查询失败:", data.message || data.error);
        renderStudentTableWithComponent([]);
        if (window.Swal) {
          Swal.fire("查询失败", data.message || data.error || "未知错误", "error");
        }
      }
    })
    .catch((error) => {
      console.error("❌ 查询异常:", error);
      renderStudentTableWithComponent([]);
      if (window.Swal) {
        Swal.fire("查询失败", `网络或服务器错误: ${error.message}`, "error");
      }
    });
}

// ✅新增：清除回调函数（与其他模块保持一致）
function onClear() {
  console.log("🧹 清除查询条件");
  renderStudentTableWithComponent([]);
  renderPagination(0, 1, 10);
}

// 🔧 配置驱动的URL构建函数
function buildModuleURL(moduleKey, studentData, moduleConfig) {
  console.log("🔧 开始构建配置驱动URL:", {
    moduleKey,
    studentData,
    moduleConfig,
  });

  let url = moduleConfig.base_url;
  const params = new URLSearchParams();

  // 🔧 修复：确保student_id参数存在
  if (studentData.id && !studentData.student_id) {
    studentData.student_id = studentData.id;
    console.log(`🔧 补充student_id字段: ${studentData.id}`);
  }

  // 添加必需参数
  console.log("🔧 添加必需参数:", moduleConfig.required_params);
  for (const paramName of moduleConfig.required_params || []) {
    const value = studentData[paramName];
    if (value !== null && value !== undefined) {
      params.append(paramName, value);
      console.log(`✅ 必需参数 ${paramName}: ${value}`);
    } else {
      console.warn(`⚠️ 必需参数 ${paramName} 为空:`, value);
    }
  }

  // 添加可选参数
  console.log("🔧 添加可选参数:", moduleConfig.optional_params);
  for (const paramName of moduleConfig.optional_params || []) {
    const value = studentData[paramName];
    if (value !== null && value !== undefined) {
      params.append(paramName, value);
      console.log(`✅ 可选参数 ${paramName}: ${value}`);
    } else {
      console.log(`ℹ️ 可选参数 ${paramName} 为空:`, value);
    }
  }

  // 🔧 修复：正确添加控制参数
  console.log("🔧 添加控制参数:", moduleConfig.control_params);
  if (Array.isArray(moduleConfig.control_params)) {
    // 如果control_params是数组格式，处理键值对字符串
    moduleConfig.control_params.forEach((paramString) => {
      if (paramString.includes('=')) {
        // 已经是键值对格式，解析并添加
        const [paramName, paramValue] = paramString.split('=');
        params.append(paramName, paramValue);
        console.log(`✅ 控制参数 ${paramName}: ${paramValue}`);
      } else {
        // 只是参数名，添加默认值true
        params.append(paramString, "true");
        console.log(`✅ 控制参数 ${paramString}: true`);
      }
    });
  } else {
    // 如果control_params是对象格式，直接使用
    for (const [paramName, paramValue] of Object.entries(
      moduleConfig.control_params || {}
    )) {
      params.append(paramName, paramValue);
      console.log(`✅ 控制参数 ${paramName}: ${paramValue}`);
    }
  }

  if (params.toString()) {
    url += "?" + params.toString();
  }

  console.log("🔗 最终构建的URL:", url);
  console.log("🔗 URL参数字符串:", params.toString());

  return url;
}

// 🔧 新增：动态表单生成器（增强版，支持API配置格式）
function generateFormFields(
  fieldsConfig,
  optionsConfig = {},
  configManager = null
) {
  let html = "";
  let fieldOrder = Object.keys(fieldsConfig);

  // 只有field_groups为非空对象时才分组渲染，否则顺序渲染
  if (
    configManager &&
    configManager.config &&
    configManager.config.field_groups &&
    Object.keys(configManager.config.field_groups).length > 0
  ) {
    // 分组渲染逻辑
    const groupConfig = configManager.config.field_groups;
    for (const groupKey in groupConfig) {
      const group = groupConfig[groupKey];
      if (group.fields && Array.isArray(group.fields)) {
        const groupFields = group.fields.filter((f) => fieldsConfig[f]);
        if (groupFields.length > 0) {
          html += `<div class="row g-2 mb-2">`;
          groupFields.forEach((fieldName) => {
            const fieldConfig = fieldsConfig[fieldName];
            if (!fieldConfig) return;
            const colClass =
              fieldConfig.col_class ||
              fieldConfig.layout_class ||
              "col-md-3 col-6";
            html += `<div class="${colClass}">`;
            const label =
              fieldConfig.label || fieldConfig.display_name || fieldName;
            const requiredMark =
              fieldConfig.required || fieldConfig.is_required
                ? ' <span class="text-danger">*</span>'
                : "";
            html += `<label class="form-label">${label}${requiredMark}</label>`;
            const fieldType =
              fieldConfig.type ||
              fieldConfig.field_type ||
              fieldConfig.input_type ||
              "input";
            if (fieldType === "select" || fieldType === "dropdown") {
              html += generateSelectField(
                fieldName,
                fieldConfig,
                optionsConfig,
                configManager
              );
            } else if (fieldType === "textarea" || fieldType === "text_area") {
              html += generateTextareaField(fieldName, fieldConfig);
            } else if (fieldType === "checkbox" || fieldType === "boolean") {
              html += `<input type="checkbox" class="form-check-input" name="${fieldName}" />`;
            } else {
              html += generateInputField(fieldName, fieldConfig, fieldType);
            }
            html += "</div>";
          });
          html += "</div>";
        }
      }
    }
    return html;
  }
  // 默认顺序渲染
  for (const fieldName of fieldOrder) {
    const fieldConfig = fieldsConfig[fieldName];
    if (!fieldConfig) continue;
    const colClass =
      fieldConfig.col_class || fieldConfig.layout_class || "col-md-3";
    html += `<div class="${colClass}">`;
    const label = fieldConfig.label || fieldConfig.display_name || fieldName;
    const requiredMark =
      fieldConfig.required || fieldConfig.is_required
        ? ' <span class="text-danger">*</span>'
        : "";
    html += `<label class="form-label">${label}${requiredMark}</label>`;
    const fieldType =
      fieldConfig.type ||
      fieldConfig.field_type ||
      fieldConfig.input_type ||
      "input";
    if (fieldType === "select" || fieldType === "dropdown") {
      html += generateSelectField(
        fieldName,
        fieldConfig,
        optionsConfig,
        configManager
      );
    } else if (fieldType === "textarea" || fieldType === "text_area") {
      html += generateTextareaField(fieldName, fieldConfig);
    } else if (fieldType === "checkbox" || fieldType === "boolean") {
      html += `<input type="checkbox" class="form-check-input" name="${fieldName}" />`;
    } else {
      html += generateInputField(fieldName, fieldConfig, fieldType);
    }
    html += "</div>";
  }
  return html;
}

// 🔧 生成select字段（完全配置驱动）
function generateSelectField(
  fieldName,
  fieldConfig,
  optionsConfig,
  configManager = null
) {
  let html = `<select class="form-select" name="${fieldName}"`;
  if (fieldConfig.required || fieldConfig.is_required) html += " required";
  html += ">";

  // 🔧 完全配置驱动：获取选项
  let options = [];

  // 方式1：直接在字段配置中定义选项
  if (fieldConfig.options && Array.isArray(fieldConfig.options)) {
    options = fieldConfig.options;
  }
  // 方式2：通过options_source引用配置中的选项
  else if (
    fieldConfig.options_source &&
    optionsConfig[fieldConfig.options_source]
  ) {
    const label = fieldConfig.label || fieldConfig.display_name || fieldName;
    options = [{ value: "", label: `选择${label}` }];
    optionsConfig[fieldConfig.options_source].forEach((item) => {
      if (typeof item === "string") {
        options.push({ value: item, label: item });
      } else if (typeof item === "object" && item.value !== undefined) {
        options.push(item);
      }
    });
  }
  // 方式3：从字段配置的选项列表获取
  else if (fieldConfig.option_list && Array.isArray(fieldConfig.option_list)) {
    options = fieldConfig.option_list;
  }
  // 🔧 如果没有配置选项，显示错误信息
  else {
    const label = fieldConfig.label || fieldConfig.display_name || fieldName;
    options = [{ value: "", label: `${label} - 配置缺失` }];
    console.error(`🚨 字段 ${fieldName} 缺少选项配置`, {
      fieldConfig,
      optionsConfig_keys: Object.keys(optionsConfig),
      configManager_available: !!configManager,
    });
  }

  // 生成选项HTML
  options.forEach((option) => {
    html += `<option value="${option.value || ""}">${
      option.label || option.text || option
    }</option>`;
  });

  html += "</select>";
  return html;
}

// 🔧 生成textarea字段
function generateTextareaField(fieldName, fieldConfig) {
  let html = `<textarea class="form-control" name="${fieldName}"`;
  if (fieldConfig.rows) html += ` rows="${fieldConfig.rows}"`;
  if (fieldConfig.required) html += " required";
  if (fieldConfig.placeholder)
    html += ` placeholder="${fieldConfig.placeholder}"`;
  html += "></textarea>";
  return html;
}

// 🔧 生成input字段（支持传入fieldType）
function generateInputField(fieldName, fieldConfig, fieldType = null) {
  let html = `<input class="form-control"`;

  // 🔧 使用传入的fieldType或从配置获取
  const inputType = fieldType || fieldConfig.type || "text";
  if (inputType && inputType !== "input") html += ` type="${inputType}"`;

  html += ` name="${fieldName}"`;
  if (fieldConfig.step) html += ` step="${fieldConfig.step}"`;
  if (fieldConfig.required || fieldConfig.is_required) html += " required";
  if (fieldConfig.placeholder)
    html += ` placeholder="${fieldConfig.placeholder}"`;
  html += " />";
  return html;
}

// 🔧 新增：配置驱动的查询表单生成（完全配置驱动）
function generateSearchForm(optionsConfig) {
  console.log("🔧 开始生成查询表单，下拉选项配置:", optionsConfig);

  const searchContainer = document.querySelector("#search-form .row");
  if (!searchContainer) {
    console.error("❌ 未找到查询表单容器 #search-form .row");
    return;
  }

  // 生成学校下拉选项（完全配置驱动）
  const schoolSelect = searchContainer.querySelector('select[name="school"]');
  console.log("🔍 学校下拉选择框查找结果:", !!schoolSelect);

  if (schoolSelect) {
    console.log("🔍 学校选项详细检查:", {
      optionsConfig_keys: Object.keys(optionsConfig),
      school_options_exists: "school_options" in optionsConfig,
      school_options_value: optionsConfig.school_options,
      school_options_length: optionsConfig.school_options?.length,
      school_options_type: typeof optionsConfig.school_options,
    });

    if (
      optionsConfig.school_options &&
      Array.isArray(optionsConfig.school_options) &&
      optionsConfig.school_options.length > 0
    ) {
      schoolSelect.innerHTML = '<option value="">选择学校</option>';
      optionsConfig.school_options.forEach((school) => {
        schoolSelect.innerHTML += `<option value="${school}">${school}</option>`;
      });
      console.log(
        "✅ 查询表单学校选项已配置驱动化，共",
        optionsConfig.school_options.length,
        "个选项"
      );
    } else {
      schoolSelect.innerHTML = '<option value="">学校配置缺失</option>';
      console.error("🚨 严重问题：配置API未返回有效的school_options");
      console.error(
        "🚨 请检查统一配置API是否包含 dropdown_options.school_options"
      );
      console.error("🚨 当前配置结构:", optionsConfig);
    }
  } else {
    console.error("❌ 未找到学校下拉选择框 select[name='school']");
  }
}

// 🔧 新增：配置驱动的主表单生成
async function generateMainForm() {
  try {
    const configManager = await getConfigManager();

    // 🔧 修复：根据API实际返回的数据结构调整映射
    console.log("🔧 开始配置驱动表单生成");
    console.log("🔍 完整配置数据:", configManager.config); // 🔧 详细检查配置API返回的数据结构
    console.log("🔍 配置API详细分析:", {
      basic_fields_keys: Object.keys(configManager.config.basic_fields || {}),
      extension_fields_keys: Object.keys(
        configManager.config.extension_fields || {}
      ),
      dropdown_options_keys: Object.keys(
        configManager.config.dropdown_options || {}
      ),
      dropdown_options_detail: configManager.config.dropdown_options,
      has_school_options:
        "school_options" in (configManager.config.dropdown_options || {}),
      school_options_value:
        configManager.config.dropdown_options?.school_options,
      all_config_keys: Object.keys(configManager.config),
    });

    // 🚨 根本问题诊断：检查统一配置API是否返回了dropdown_options
    if (!configManager.config.dropdown_options) {
      console.error("🚨 根本问题：统一配置API未返回 dropdown_options 字段");
      console.error("🚨 这是配置API的问题，不是前端问题");
      console.error(
        "🚨 需要检查后端统一配置API: /api/students/complete/config"
      );
      console.error("🚨 API应该返回包含 dropdown_options 的完整配置");
    } else if (
      Object.keys(configManager.config.dropdown_options).length === 0
    ) {
      console.error("🚨 根本问题：dropdown_options 字段存在但为空对象");
      console.error("🚨 后端配置API需要填充学校选项等下拉数据");
    }

    // 🔧 修复：直接从配置根级别获取字段配置
    const basicFields = configManager.config.basic_fields || {};
    const extensionFields = configManager.config.extension_fields || {};

    // 🔧 构建表单字段配置
    const formConfig = {
      basic_fields: basicFields,
      health_fields: extensionFields, // 扩展字段作为健康信息字段
    };

    // 🔧 构建下拉选项配置（完全配置驱动，移除硬编码）
    const optionsConfig = configManager.config.dropdown_options || {};

    console.log("� 修复后的表单字段配置:", formConfig);
    console.log("🔍 修复后的下拉选项配置:", optionsConfig);
    console.log("🔍 基本字段详情:", basicFields);
    console.log("🔍 扩展字段详情:", extensionFields);

    // 验证DOM容器存在性
    const basicInfoContainer = document.querySelector("#basic-info .row");
    const healthInfoContainer = document.querySelector("#health-info .row");

    console.log("🔍 DOM容器查找结果:", {
      basicInfoContainer: !!basicInfoContainer,
      healthInfoContainer: !!healthInfoContainer,
      basicInfoElement: basicInfoContainer,
      healthInfoElement: healthInfoContainer,
    });

    // 🔧 如果找不到.row容器，直接使用父容器
    const actualBasicContainer =
      basicInfoContainer || document.querySelector("#basic-info");
    const actualHealthContainer =
      healthInfoContainer || document.querySelector("#health-info");
    console.log("🔍 实际使用的容器:", {
      actualBasicContainer: !!actualBasicContainer,
      actualHealthContainer: !!actualHealthContainer,
    });

    // 生成基本信息字段
    if (
      formConfig.basic_fields &&
      Object.keys(formConfig.basic_fields).length > 0
    ) {
      console.log("🔧 开始生成基本信息字段:", formConfig.basic_fields);
      if (basicInfoContainer) {
        const basicFieldsHTML = generateFormFields(
          formConfig.basic_fields,
          optionsConfig,
          configManager
        );
        console.log("🔧 生成的基本信息HTML:", basicFieldsHTML);
        basicInfoContainer.innerHTML = basicFieldsHTML;
        console.log("✅ 基本信息表单已配置驱动化生成");
      } else if (actualBasicContainer) {
        console.log("🔄 使用基本信息父容器");
        const rowDiv = document.createElement("div");
        rowDiv.className = "row g-3";
        rowDiv.innerHTML = generateFormFields(
          formConfig.basic_fields,
          optionsConfig,
          configManager
        );
        actualBasicContainer.appendChild(rowDiv);
        console.log("✅ 基本信息表单已配置驱动化生成（父容器）");
      } else {
        console.error("❌ 未找到基本信息容器");
      }
    } else {
      console.error("🚨 严重问题：配置API未返回基本字段配置");
      console.error("🚨 这违反了统一配置架构要求，前端无法生成表单");
      console.error(
        "🚨 请检查：/api/students/complete/config 是否返回 config.basic_fields"
      );
      console.error("🚨 实际配置结构:", configManager.config);
      
      // 🔧 严格配置驱动架构：配置加载失败时，暴露问题并中断操作
      const errorMessage = `配置驱动架构错误：学生档案基本字段配置加载失败。这违反了配置驱动原则，必须修复配置服务。`;
      console.error("❌ 配置驱动架构错误:", errorMessage);
      
      if (window.Swal) {
        Swal.fire("配置驱动架构错误", errorMessage, "error");
      } else {
        alert(`配置驱动架构错误: ${errorMessage}`);
      }
      throw new Error(errorMessage);
    }

    // 生成健康信息字段
    if (
      formConfig.health_fields &&
      Object.keys(formConfig.health_fields).length > 0
    ) {
      console.log("🔧 开始生成健康信息字段:", formConfig.health_fields);
      if (healthInfoContainer) {
        const healthFieldsHTML = generateFormFields(
          formConfig.health_fields,
          optionsConfig,
          configManager
        );
        console.log("🔧 生成的健康信息HTML:", healthFieldsHTML);
        healthInfoContainer.innerHTML = healthFieldsHTML;
        console.log("✅ 健康信息表单已配置驱动化生成");
      } else if (actualHealthContainer) {
        console.log("🔄 使用健康信息父容器");
        const rowDiv = document.createElement("div");
        rowDiv.className = "row g-3";
        rowDiv.innerHTML = generateFormFields(
          formConfig.health_fields,
          optionsConfig,
          configManager
        );
        actualHealthContainer.appendChild(rowDiv);
        console.log("✅ 健康信息表单已配置驱动化生成（父容器）");
      } else {
        console.error("❌ 未找到健康信息容器");
      }
    } else {
      console.error("🚨 严重问题：配置API未返回扩展字段配置");
      console.error("🚨 这违反了统一配置架构要求，前端无法生成健康表单");
      console.error(
        "🚨 请检查：/api/students/complete/config 是否返回 config.extension_fields"
      );
      console.error("🚨 实际配置结构:", configManager.config);
      
      // 🔧 严格配置驱动架构：配置加载失败时，暴露问题并中断操作
      const errorMessage = `配置驱动架构错误：学生档案扩展字段配置加载失败。这违反了配置驱动原则，必须修复配置服务。`;
      console.error("❌ 配置驱动架构错误:", errorMessage);
      
      if (window.Swal) {
        Swal.fire("配置驱动架构错误", errorMessage, "error");
      } else {
        alert(`配置驱动架构错误: ${errorMessage}`);
      }
      throw new Error(errorMessage);
    }

    // 扩展字段表单已生成完成
  } catch (error) {
    console.error("❌ 配置驱动表单生成失败:", error);
    
    // 严格配置驱动架构：配置加载失败时，暴露问题并中断操作
    const errorMessage = `配置驱动架构错误：学生档案表单配置加载失败。这违反了配置驱动原则，必须修复配置服务。错误详情: ${error.message}`;
    console.error("❌ 配置驱动架构错误:", errorMessage);
    
    if (window.Swal) {
      Swal.fire("配置驱动架构错误", errorMessage, "error");
    } else {
      alert(`配置驱动架构错误: ${errorMessage}`);
    }
    throw new Error(errorMessage);
  }
}

// 🔧 获取配置管理器的辅助函数
async function getConfigManager() {
  if (studentConfigManager) {
    return studentConfigManager;
  }
  
  // 如果配置管理器不存在，尝试重新加载
  console.log("🔄 配置管理器不存在，重新加载学生档案配置...");
  await loadStudentConfig();
  
  if (studentConfigManager) {
    return studentConfigManager;
  }
  
  throw new Error("无法获取学生档案配置管理器");
}

document.addEventListener("DOMContentLoaded", function () {
  console.log("学生档案完整录入页面初始化完成");
  
  // 🔧 加载配置驱动架构并初始化查看模式
  loadStudentConfig().then(() => {
    console.log("✅ 配置加载完成，开始初始化页面");
    
    // 🔧 确保查询区渲染
    renderQueryArea();
    
    // 🔧 立即生成表单，确保基本信息和健康信息表单存在
    generateMainForm().then(() => {
      console.log("✅ 表单生成完成");
      
      // 🔧 修复：延迟绑定跳转按钮，确保表单生成完成后再绑定
      setTimeout(() => {
        bindJumpButtons();
      }, 500);
      
    }).catch((error) => {
      console.error("❌ 表单生成失败:", error);
    });
    
    // 检查是否为新增模式（通过URL参数或其他方式判断）
    const urlParams = new URLSearchParams(window.location.search);
    const isNewMode = urlParams.get('mode') === 'new' || window.location.pathname.includes('new');
    
    if (isNewMode) {
      isNewRecord = true;
      selectedStudent = null;
      // 新增模式下默认为编辑模式
      setTimeout(() => {
        switchToMode("edit");
        console.log("✅ 新增模式：初始化为编辑模式");
      }, 100);
    } else {
      // 查看现有学生时默认为只读模式
      setTimeout(() => {
        switchToMode("readonly");
        console.log("✅ 查看模式：初始化为只读模式");
      }, 100);
    }
  }).catch((error) => {
    console.error("❌ 配置加载失败:", error);
    // 即使配置加载失败，也要确保查询区能正常显示
    if (typeof renderQueryArea === 'function') {
      renderQueryArea();
    }
  });

  // 操作按钮事件绑定
  document.getElementById("btn-back").addEventListener("click", backToList);
  document
    .getElementById("btn-readonly")
    .addEventListener("click", function () {
      switchToMode("readonly");
    });
  document.getElementById("btn-edit").addEventListener("click", function () {
    if (!selectedStudent && !isNewRecord) {
      Swal.fire("提示", "请先选择学生", "warning");
      return;
    }
    switchToMode("edit");
  });
  document.getElementById("btn-modify").addEventListener("click", function () {
    if (!selectedStudent && !isNewRecord) {
      Swal.fire("提示", "请先选择学生", "warning");
      return;
    }
    switchToMode("modify");
  });
  document.getElementById("btn-save").addEventListener("click", handleSave);

  // 🔧 配置驱动的视力记录按钮点击处理
  async function handleVisionClick() {
    console.log("跳转到视力记录页面");

    if (!selectedStudent && !isNewRecord) {
      Swal.fire("提示", "请先选择学生", "warning");
      return;
    }

    // 新增模式下，提示先保存学生信息
    if (isNewRecord) {
      Swal.fire("提示", "请先保存学生基本信息，然后再进行视力录入", "warning");
      return;
    }

    console.log("🔍 当前选中学生完整信息:", selectedStudent);

    // 检查学生数据完整性
    if (!selectedStudent.name || selectedStudent.name.trim() === "") {
      console.error("学生姓名为空，检查数据加载:", selectedStudent);
      Swal.fire("错误", "学生姓名信息缺失，请重新选择学生", "error");
      return;
    }

    try {
      // 🔧 使用配置驱动构建跳转URL
      const configManager = await getConfigManager();
      const moduleConfig = configManager.getModuleIntegration();

      console.log("🔍 获取到的模块配置:", moduleConfig);
      console.log("🔍 视力记录模块配置:", moduleConfig.vision_record);

      const url = buildModuleURL(
        "vision_record",
        selectedStudent,
        moduleConfig.vision_record
      );
      console.log("🔗 配置驱动视力跳转URL:", url);

      // 跳转到视力记录页面
      window.location.href = url;
    } catch (error) {
      // 严格配置驱动架构：配置驱动跳转失败时，暴露问题并中断操作
      const errorMessage = `配置驱动架构错误：视力模块跳转配置失败。这违反了配置驱动原则，必须修复模块集成配置。错误详情: ${error.message}`;
      console.error("❌ 配置驱动架构错误:", errorMessage);
      
      if (window.Swal) {
        Swal.fire("配置驱动架构错误", errorMessage, "error");
      } else {
        alert(`配置驱动架构错误: ${errorMessage}`);
      }
      throw new Error(errorMessage);
    }
  }  // 🔧 配置驱动的干预记录按钮点击处理
  async function handleInterventionClick() {
    console.log("跳转到干预记录页面");

    if (!selectedStudent && !isNewRecord) {
      Swal.fire("提示", "请先选择学生", "warning");
      return;
    }

    // 新增模式下，提示先保存学生信息
    if (isNewRecord) {
      Swal.fire("提示", "请先保存学生基本信息，然后再进行干预录入", "warning");
      return;
    }

    console.log("🔍 当前选中学生:", selectedStudent);

    try {
      // 🔧 使用配置驱动构建跳转URL
      const configManager = await getConfigManager();
      const moduleConfig = configManager.getModuleIntegration();

      console.log("🔍 干预记录模块配置:", moduleConfig.intervention_record);

      const url = buildModuleURL(
        "intervention_record",
        selectedStudent,
        moduleConfig.intervention_record
      );
      console.log("🔗 配置驱动干预跳转URL:", url);

      // 跳转到干预记录页面
      window.location.href = url;
    } catch (error) {
      // 严格配置驱动架构：配置驱动跳转失败时，暴露问题并中断操作
      const errorMessage = `配置驱动架构错误：干预模块跳转配置失败。这违反了配置驱动原则，必须修复模块集成配置。错误详情: ${error.message}`;
      console.error("❌ 配置驱动架构错误:", errorMessage);
      
      if (window.Swal) {
        Swal.fire("配置驱动架构错误", errorMessage, "error");
      } else {
        alert(`配置驱动架构错误: ${errorMessage}`);
      }
      throw new Error(errorMessage);
    }
  }  // 🔧 配置驱动的随访记录按钮点击处理
  async function handleFollowupClick() {
    console.log("跳转到随访记录页面");

    if (!selectedStudent) {
      Swal.fire("提示", "请先选择学生", "warning");
      return;
    }

    console.log("🔍 当前选中学生:", selectedStudent);

    try {
      // 🔧 使用配置驱动构建跳转URL
      const configManager = await getConfigManager();
      const moduleConfig = configManager.getModuleIntegration();

      console.log("🔍 随访记录模块配置:", moduleConfig.followup_record);

      const url = buildModuleURL(
        "followup_record",
        selectedStudent,
        moduleConfig.followup_record
      );
      console.log("🔗 配置驱动随访跳转URL:", url);

      // 跳转到随访记录页面
      window.location.href = url;
    } catch (error) {
      // 严格配置驱动架构：配置驱动跳转失败时，暴露问题并中断操作
      const errorMessage = `配置驱动架构错误：随访模块跳转配置失败。这违反了配置驱动原则，必须修复模块集成配置。错误详情: ${error.message}`;
      console.error("❌ 配置驱动架构错误:", errorMessage);
      
      if (window.Swal) {
        Swal.fire("配置驱动架构错误", errorMessage, "error");
      } else {
        alert(`配置驱动架构错误: ${errorMessage}`);
      }
      throw new Error(errorMessage);
    }
  }

  // 🔧 学生档案日志按钮点击处理
  function handleLogClick() {
    console.log("查看学生档案日志");

    if (!selectedStudent && !isNewRecord) {
      Swal.fire("提示", "请先选择学生", "warning");
      return;
    }

    // 新增模式下，提示先保存学生信息
    if (isNewRecord) {
      Swal.fire("提示", "请先保存学生基本信息，然后再查看日志", "warning");
      return;
    }

    console.log("🔍 当前选中学生:", selectedStudent);

    // 检查学生数据完整性
    if (!selectedStudent.id) {
      console.error("学生ID缺失，检查数据加载:", selectedStudent);
      Swal.fire("错误", "学生ID信息缺失，请重新选择学生", "error");
      return;
    }

    // 调用已有的日志显示函数
    showStudentLogs(selectedStudent.id);
  }

  // 修复：增强调试函数，显示所有按钮信息
  function checkButtonsExist() {
    console.log("=== 页面按钮检查 ===");

    // 检查所有按钮
    const allButtons = document.querySelectorAll("button");
    console.log(`页面共有 ${allButtons.length} 个按钮:`);

    allButtons.forEach((btn, index) => {
      console.log(`按钮${index}:`, {
        id: btn.id || "无ID",
        class: btn.className || "无class",
        text: btn.textContent.trim(),
        element: btn,
      });
    });

    // 检查是否在student-detail区域内
    const studentDetail = document.getElementById("student-detail");
    if (studentDetail) {
      const detailButtons = studentDetail.querySelectorAll("button");
      console.log(`student-detail区域内有 ${detailButtons.length} 个按钮:`);
      detailButtons.forEach((btn, index) => {
        console.log(`detail按钮${index}:`, {
          id: btn.id || "无ID",
          class: btn.className || "无class",
          text: btn.textContent.trim(),
        });
      });
    }

    console.log("=== 检查结束 ===");

    // 修复：提供按钮测试功能    console.log("提供按钮测试命令：");
    console.log("window.testVisionButton() - 测试视力记录按钮");
    console.log("window.testInterventionButton() - 测试干预记录按钮");
    console.log("window.testFollowupButton() - 测试随访记录按钮");
  }

  // 修复：在页面加载完成后检查按钮
  setTimeout(() => {
    console.log("检查页面按钮是否存在...");
    checkButtonsExist();
  }, 1000);

  // 表单提交
  document
    .getElementById("student-form")
    .addEventListener("submit", function (e) {
      e.preventDefault();
      handleSave();
    });

  // 折叠/展开功能
  bindSectionToggle();

  // 查询学生（完全配置驱动架构）

  // ✅新增：获取当前查询参数（与其他模块保持一致）
  function getCurrentQueryParams() {
    const params = {};
    const queryInputs = document.querySelectorAll('#fixedQueryArea input, #fixedQueryArea select');
    queryInputs.forEach(input => {
      if (input.value && input.name) {
        params[input.name] = input.value;
      }
    });
    return params;
  }

  // 🔧 重新执行查询，保持查询状态（用于恢复后刷新）
  function refreshQueryResults() {
    console.log("🔄 恢复后刷新查询结果，当前查询参数:", currentQueryParams);
    
    if (currentQueryParams) {
      // 重新执行查询，保持当前查询条件
      queryStudents(1, currentQueryParams);
    } else {
      // 如果没有查询参数，执行默认查询
      queryStudents(1, {});
    }
  }

  // ✅新增：使用QueryResultTable组件渲染学生表格（与其他模块保持一致）
  async function renderStudentTableWithComponent(students) {
    if (!window.renderQueryResultTable) {
      console.error("❌ QueryResultTable组件未加载");
      return;
    }

    // 显示结果表格容器
    document.getElementById("search-results").style.display = "block";
    document.getElementById("student-detail").style.display = "none";

    try {
      // 使用新的自包含QueryResultTable API（与其他模块完全一致）
      await window.renderQueryResultTable(students, 'student_archive', 'query', {
        showRowNumber: true,
        onRowClick: (row, index) => {
          console.log('点击学生行:', row, index);
        }
      });
      
      console.log('✅ 学生档案模块表格渲染完成，数据量:', students?.length || 0);
    } catch (error) {
      console.error('❌ 学生档案模块表格渲染失败:', error);
      
      // 降级处理：显示错误信息
      const tableBody = document.getElementById('queryTableBody');
      if (tableBody) {
        tableBody.innerHTML = `
          <tr>
            <td colspan="100%" class="text-center text-danger py-4">
              <i class="fas fa-exclamation-triangle fa-2x mb-2 d-block"></i>
              <div>表格渲染失败: ${error.message}</div>
            </td>
          </tr>
        `;
      }
    }
  }
  
  // 🔧 新增：备用渲染方式（当QueryResultTable组件不可用时）
  function renderStudentTableFallback(students) {
    console.log("🔧 使用备用方式渲染学生表格:", students);
    
    const table = document.getElementById("results-table");
    const thead = table.querySelector("thead tr");
    const tbody = table.querySelector("tbody");
    
    // 清空表格内容
    thead.innerHTML = "";
    tbody.innerHTML = "";

    if (!students.length) {
      // 使用配置驱动表头
      if (queryFieldsConfig) {
        queryFieldsConfig.forEach(field => {
          const th = document.createElement("th");
          th.textContent = field.display_name || field.field;
          thead.appendChild(th);
        });
      }
      // 添加操作列
      const operationTh = document.createElement("th");
      operationTh.textContent = "操作";
      thead.appendChild(operationTh);
      
      const colspan = thead.children.length;
      tbody.innerHTML = `<tr><td colspan="${colspan}" class="text-center text-muted">暂无数据</td></tr>`;
      document.getElementById("search-results").style.display = "block";
      return;
    }

    // 渲染表头（配置驱动）
    if (queryFieldsConfig) {
      queryFieldsConfig.forEach(field => {
        const th = document.createElement("th");
        th.textContent = field.display_name || field.field;
        thead.appendChild(th);
      });
    }
    
    // 添加操作列
    const operationTh = document.createElement("th");
    operationTh.textContent = "操作";
    thead.appendChild(operationTh);

    // 渲染表格内容（配置驱动）
    students.forEach((student) => {
      const row = document.createElement("tr");
      
      if (queryFieldsConfig) {
        // 使用配置驱动渲染
        queryFieldsConfig.forEach(field => {
          const td = document.createElement("td");
          const value = student[field.field];
          td.textContent = value || "";
          row.appendChild(td);
        });
      }
      
      // 操作按钮
      const actionTd = document.createElement("td");
      actionTd.innerHTML = `
        <button type="button" class="btn btn-primary btn-sm me-1" onclick="viewStudentRecord(${student.id})">查看档案</button>
        <button type="button" class="btn btn-secondary btn-sm btn-log-student" data-id="${student.id}">日志</button>
      `;
      row.appendChild(actionTd);
      
      tbody.appendChild(row);
    });

    document.getElementById("search-results").style.display = "block";
    document.getElementById("student-detail").style.display = "none";
    
    // 绑定日志按钮事件
    bindStudentLogButtons();
  }

  // ✅新增：渲染分页（与其他模块保持一致）
  function renderPagination(total, page, per_page) {
    const pageCount = Math.ceil(total / per_page);
    const paginationContainer = document.getElementById("queryPagination");
    
    if (!paginationContainer) {
      console.error("❌ 找不到分页容器: queryPagination");
      return;
    }
    
    if (pageCount <= 1) {
      paginationContainer.innerHTML = "";
      return;
    }
    
    let html = "";
    html += `<li class="page-item ${page === 1 ? 'disabled' : ''}">`;
    html += `<a class="page-link" href="#" data-page="${page - 1}">上一页</a></li>`;
    
    let start = Math.max(1, page - 2);
    let end = Math.min(pageCount, page + 2);
    
    if (start > 1) {
      html += `<li class="page-item disabled"><span class="page-link">...</span></li>`;
    }
    
    for (let i = start; i <= end; i++) {
      html += `<li class="page-item ${i === page ? 'active' : ''}">`;
      html += `<a class="page-link" href="#" data-page="${i}">${i}</a></li>`;
    }
    
    if (end < pageCount) {
      html += `<li class="page-item disabled"><span class="page-link">...</span></li>`;
    }
    
    html += `<li class="page-item ${page === pageCount ? 'disabled' : ''}">`;
    html += `<a class="page-link" href="#" data-page="${page + 1}">下一页</a></li>`;
    
    paginationContainer.innerHTML = html;
    
    // 绑定分页事件
    paginationContainer.querySelectorAll(".page-link").forEach((link) => {
      link.addEventListener("click", function (e) {
        e.preventDefault();
        const toPage = parseInt(this.getAttribute("data-page"));
        if (!isNaN(toPage) && toPage !== page && toPage >= 1 && toPage <= pageCount) {
          // 重新执行查询，传递当前查询参数和页码
          const currentParams = getCurrentQueryParams();
          currentParams.page = toPage;
          queryStudents(toPage, currentParams);
        }
      });
    });
  }

  // 查看学生档案（全局函数）
  function viewStudentRecord(studentId) {
    console.log("查看学生档案:", studentId);
    loadStudentData(studentId).then(() => {
      // 🔧 新增：显示学生信息条
      if (selectedStudent && window.renderStudentInfoBar) {
        renderStudentInfoBar(selectedStudent, {
          moduleName: 'student_archive',
          containerId: 'student-info-bar',
          autoShow: true,
          onError: (error) => {
            console.error('❌ 学生信息条组件渲染失败:', error);
          }
        });
      }
      
      showStudentForm();
      // 🔧 延迟设置查看模式，确保表单生成完成
      setTimeout(() => {
        switchToMode("readonly");
        console.log("✅ 查看学生档案 - 设置为查看模式");
      }, 200);
    });
  }

  // 创建新学生档案
  function createNewRecord() {
    selectedStudent = null;
    isNewRecord = true;
    const form = document.getElementById("student-form");
    if (form) {
      form.reset();
    }
    showStudentForm();
    
    // 确保在表单生成完成后设置为编辑模式
    setTimeout(() => {
      switchToMode("edit");
      console.log("✅ 新增学生档案：强制设置为编辑模式");
    }, 200);
  }

  // 修复：定义缺失的 handleSave 函数
  function handleSave() {
    if (currentMode === "readonly") {
      Swal.fire("提示", "当前为只读模式，无法保存", "info");
      return;
    }

    const formData = new FormData(document.getElementById("student-form"));
    const data = {};

    for (let [key, value] of formData.entries()) {
      data[key] = value;
    }

    // 处理复选框
    document.querySelectorAll('input[type="checkbox"]').forEach((checkbox) => {
      data[checkbox.name] = checkbox.checked;
    });

    // 🔧 确保data_year字段存在（必填字段）
    if (!data.data_year) {
      data.data_year = new Date().getFullYear().toString(); // 使用当前年份
    }

    const url = isNewRecord
      ? "/api/students/complete"
      : "/api/students/complete/" + selectedStudent.id;
    const method = isNewRecord ? "POST" : "PUT";

    console.log("保存学生档案数据:", data);

    fetch(url, {
      method: method,
      headers: {
        "Content-Type": "application/json",
      },
      body: JSON.stringify(data),
    })
      .then((response) => {
        if (!response.ok) {
          return response.json().then(errorData => {
            throw new Error(`HTTP ${response.status}: ${errorData.error || errorData.message || 'Unknown error'}`);
          });
        }
        return response.json();
      })
      .then((result) => {
        if (result.success) {
          Swal.fire("保存成功", "学生档案已保存", "success").then(() => {
            if (isNewRecord) {
              selectedStudent = result.data;
              isNewRecord = false;
            }
            switchToMode("readonly");
          });
        } else {
          Swal.fire("保存失败", result.error || result.message || "未知错误", "error");
        }
      })
      .catch((error) => {
        console.error("保存学生档案出错:", error);
        Swal.fire("保存失败", error.message || "网络错误或服务器错误", "error");
      });
  }

  // 修复：定义缺失的切换编辑模式函数
  function switchToMode(mode) {
    console.log("🔧 切换模式:", mode);
    currentMode = mode;
    const form = document.getElementById("student-form");

    if (!form) {
      console.error("找不到student-form表单，无法切换模式");
      return;
    }

    console.log("✅ 找到表单，开始切换模式:", mode);

    // 移除所有模式类
    form.classList.remove("readonly-mode", "edit-mode", "modify-mode");
    form.classList.add(mode + "-mode");

    // 设置表单元素状态
    const inputs = form.querySelectorAll("input, select, textarea");
    console.log("🔧 找到", inputs.length, "个输入元素");
    
    inputs.forEach((input) => {
      if (mode === "readonly") {
        input.disabled = true;
      } else if (mode === "edit") {
        // 新增模式：所有字段都可编辑
        if (isNewRecord) {
          input.disabled = false;
        } else {
          // 编辑模式：只能填写空白字段
          input.disabled = !!(input.value && input.value.trim());
        }
      } else if (mode === "modify") {
        // 修改模式：可以修改所有字段
        input.disabled = false;
      }
    });

    updateButtonStates();
  }

  // 修复：定义缺失的更新按钮状态函数
  function updateButtonStates() {
    const btnReadonly = document.getElementById("btn-readonly");
    const btnEdit = document.getElementById("btn-edit");
    const btnModify = document.getElementById("btn-modify");
    const btnSave = document.getElementById("btn-save");

    if (btnReadonly)
      btnReadonly.classList.toggle("active", currentMode === "readonly");
    if (btnEdit) btnEdit.classList.toggle("active", currentMode === "edit");
    if (btnModify)
      btnModify.classList.toggle("active", currentMode === "modify");
    if (btnSave)
      btnSave.style.display =
        currentMode !== "readonly" ? "inline-block" : "none";
  }

  // 修复：定义缺失的绑定折叠/展开功能
  function bindSectionToggle() {
    console.log("绑定折叠展开功能...");

    // 使用Bootstrap 5.x的折叠组件
    document.querySelectorAll(".section-header").forEach((header) => {
      header.addEventListener("click", function () {
        console.log("折叠标题被点击:", this.textContent.trim());

        // 获取目标折叠内容
        const target = this.getAttribute("data-bs-target");
        const content = document.querySelector(target);
        const icon = this.querySelector(".toggle-icon");

        if (!content) {
          console.error("未找到折叠目标:", target);
          return;
        }

        console.log("折叠目标元素:", content);

        // Bootstrap 5.x 折叠控制
        const bsCollapse = new bootstrap.Collapse(content, {
          toggle: false,
        });

        // 检查当前状态并切换
        if (content.classList.contains("show")) {
          console.log("当前展开，执行折叠");
          bsCollapse.hide();
          // 更新图标
          if (icon) {
            icon.classList.remove("bi-chevron-up");
            icon.classList.add("bi-chevron-down");
          }
          // 更新header状态
          this.classList.add("collapsed");
        } else {
          console.log("当前折叠，执行展开");
          bsCollapse.show();
          // 更新图标
          if (icon) {
            icon.classList.remove("bi-chevron-down");
            icon.classList.add("bi-chevron-up");
          }
          // 更新header状态
          this.classList.remove("collapsed");
        }
      });
    });

    console.log("折叠展开功能绑定完成");
  }

  // 修复：定义缺失的加载学生完整数据函数
  function loadStudentData(studentId) {
    console.log("加载学生数据，ID:", studentId);
    // 使用专门的学生完整信息接口
    return fetch("/api/students/complete/" + studentId)
      .then((response) => response.json())
      .then((data) => {
        console.log("学生完整数据返回:", data);
        if (data.success && data.data) {
          selectedStudent = data.data;
          isNewRecord = false;
          fillBasicForm(selectedStudent);
          // 加载关联记录信息
          loadRelatedRecordsInfo(studentId);
        } else {
          throw new Error(data.error || "获取学生信息失败");
        }
      })
      .catch((error) => {
        console.error("加载学生数据失败:", error);
        Swal.fire("错误", "加载学生数据失败: " + error.message, "error");
      });
  }

  // 修复：定义缺失的加载关联记录信息函数
  function loadRelatedRecordsInfo(studentId) {
    fetch("/api/students/complete/" + studentId + "/related")
      .then((response) => {
        if (!response.ok) {
          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }
        return response.json();
      })
      .then((data) => {
        if (data.success && data.data) {
          // 显示最近记录统计
          updateRecordCounts(data.data);
          // 可选：显示最近记录的详细信息
          displayRecentRecords(data.data);
        } else {
          console.warn("⚠️ 关联记录加载失败:", data.error || "未知错误");
        }
      })
      .catch((error) => {
        console.warn("⚠️ 加载关联记录失败:", error.message);
        // 不影响主要功能，只显示警告
        // 设置默认的记录统计
        updateRecordCounts({
          vision_count: 0,
          intervention_count: 0,
          followup_count: 0
        });
      });
  }

  // 修复：定义缺失的更新记录统计信息函数
  function updateRecordCounts(relatedData) {
    // 更新视力记录数量
    const visionCountElement = document.getElementById("vision-record-count");
    if (visionCountElement) {
      visionCountElement.textContent = relatedData.vision_count || 0;
    }

    // 更新干预记录数量
    const interventionCountElement = document.getElementById(
      "intervention-record-count"
    );
    if (interventionCountElement) {
      interventionCountElement.textContent =
        relatedData.intervention_count || 0;
    }

    // 更新随访记录数量
    const followupCountElement = document.getElementById(
      "followup-record-count"
    );
    if (followupCountElement) {
      followupCountElement.textContent = relatedData.followup_count || 0;
    }
  }

  // 修复：定义缺失的显示最近记录信息函数
  function displayRecentRecords(relatedData) {
    // 可以在界面上显示最近的记录时间或内容
    // 这里可以根据需要实现具体的显示逻辑
    console.log("最近记录信息:", {
      vision: relatedData.vision_records?.[0],
      intervention: relatedData.intervention_records?.[0],
      followup: relatedData.followup_records?.[0],
    });
  }

  // 修复：定义缺失的填充表单函数
  function fillBasicForm(student) {
    console.log("填充表单数据:", student);
    
    const form = document.getElementById("student-form");
    if (!form) {
      console.error("找不到student-form表单");
      return;
    }

    // 健康信息字段的直接映射（避免接口问题）
    const healthFields = {
      data_year: student.data_year || "",
      grade: student.grade || "",
      height: student.height || "",
      weight: student.weight || "",
      diet_preference: student.diet_preference || "",
      exercise_preference: student.exercise_preference || "",
      health_education: student.health_education || "",
      past_history: student.past_history || "",
      family_history: student.family_history || "",
      premature: student.premature || "",
      allergy: student.allergy || "",
      correction_method: student.correction_method || "",
    };

    // 先填充健康信息字段
    for (const [fieldName, value] of Object.entries(healthFields)) {
      const input = form.querySelector('[name="' + fieldName + '"]');
      if (input) {
        input.value = value;
        console.log("成功填充健康字段 " + fieldName + ":", value);
      }
    }

    // 然后填充其他所有字段
    for (const [key, value] of Object.entries(student)) {
      const input = form.querySelector('[name="' + key + '"]');
      if (input && !healthFields.hasOwnProperty(key)) {
        if (input.type === "checkbox") {
          input.checked = !!value;
        } else if (input.type === "date" && value) {
          input.value = value.split("T")[0];
        } else {
          input.value = value || "";
        }
        console.log("成功填充字段 " + key + ":", value);
      }
    }

    // 年龄特殊处理：优先使用数据库值，空时才计算
    const ageInput = form.querySelector('[name="age"]');
    if (ageInput) {
      if (student.age && student.age !== "") {
        ageInput.value = student.age;
        console.log("使用数据库年龄:", student.age);
      } else if (student.birthday) {
        const birthday = new Date(student.birthday);
        const today = new Date();
        let age = today.getFullYear() - birthday.getFullYear();
        const monthDiff = today.getMonth() - birthday.getMonth();
        if (
          monthDiff < 0 ||
          (monthDiff === 0 && today.getDate() < birthday.getDate())
        ) {
          age--;
        }
        ageInput.value = age;
        console.log("自动计算年龄:", age);
      }
    }

    // 🔧 配置驱动的布尔字段处理
    fillBooleanFieldsWithConfig(student, form);
  }
  // 🔧 新增：配置驱动的布尔字段处理函数
  async function fillBooleanFieldsWithConfig(student, form) {
    try {
      const configManager = await getConfigManager();
      const fieldConfigs = configManager.config.basic_fields || {};

      // 从配置中获取布尔字段
      const booleanFields = Object.keys(fieldConfigs).filter((fieldName) => {
        const config = fieldConfigs[fieldName];
        return config && config.field_type === "boolean";
      });

      console.log("🔧 配置驱动的布尔字段:", booleanFields);

      booleanFields.forEach((field) => {
        const checkbox = form.querySelector('[name="' + field + '"]');
        if (checkbox && checkbox.type === "checkbox") {
          checkbox.checked = !!student[field];
          console.log("配置驱动布尔字段 " + field + ":", !!student[field]);
        }
      });
    } catch (error) {
      console.warn("⚠️ 配置API未返回布尔字段配置，跳过复选框字段处理:", error);
      // 🔧 完全移除硬编码回退：如果配置API不可用，则不处理复选框字段
    }
  }
  // 显示学生档案表单
  function showStudentForm() {
    document.getElementById("search-results").style.display = "none";
    // 修复：使用正确的分页容器ID
    const paginationContainer = document.getElementById("queryPagination");
    if (paginationContainer) {
      paginationContainer.style.display = "none";
    }
    document.getElementById("student-detail").style.display = "block";

    // 调试信息：显示当前选中的学生
    if (selectedStudent) {
      console.log("当前选中学生信息:", {
        id: selectedStudent.id,
        name: selectedStudent.name,
        education_id: selectedStudent.education_id,
      });
    } // 🔧 确保表单已生成
    setTimeout(() => {
      console.log("🔧 确保表单生成 - 重新触发配置驱动表单生成...");
      generateMainForm()
        .then(() => {
          console.log("✅ 表单确认生成完成");
          // 表单生成后填充数据
          if (selectedStudent) {
            fillBasicForm(selectedStudent);
          }
          // 🔧 表单生成和数据填充完成后，根据是否为新增模式设置正确的模式
          setTimeout(() => {
            if (isNewRecord) {
              switchToMode("edit");
              console.log("✅ 新增模式：表单生成后设置为编辑模式");
            } else {
              switchToMode("readonly");
              console.log("✅ 查看模式：表单生成后设置为只读模式");
            }
          }, 50);
        })
        .catch((error) => {
          console.error("表单确认生成失败:", error);
        });
    }, 50);

    // 修复：立即绑定按钮事件，确保按钮可点击
    setTimeout(() => {
      console.log("开始为学生详情页面绑定跳转按钮...");
      bindJumpButtons();
      // 验证绑定结果
      verifyButtonBinding();
    }, 100);
  }

  // 修复：增强按钮绑定函数，使用正确的按钮ID
  function bindJumpButtons() {
    console.log("开始绑定跳转按钮...");

    // 修复：使用HTML中实际存在的按钮ID
    const studentDetail = document.getElementById("student-detail");
    if (!studentDetail) {
      console.error("学生详情区域不存在");
      return;
    }

    // 修复：查找正确的按钮ID（inline版本）
    const visionBtn = studentDetail.querySelector("#btn-vision-record-inline");
    const interventionBtn = studentDetail.querySelector(
      "#btn-intervention-record-inline"
    );
    const followupBtn = studentDetail.querySelector(
      "#btn-followup-record-inline"
    );

    // 同时查找顶部的快捷按钮
    const visionBtnTop = studentDetail.querySelector("#btn-vision-record");
    const interventionBtnTop = studentDetail.querySelector(
      "#btn-intervention-record"
    );
    const followupBtnTop = studentDetail.querySelector("#btn-followup-record");
    const logBtn = studentDetail.querySelector("#btn-student-log");

    console.log("学生详情区域按钮查找结果:", {
      visionInline: !!visionBtn,
      interventionInline: !!interventionBtn,
      followupInline: !!followupBtn,
      visionTop: !!visionBtnTop,
      interventionTop: !!interventionBtnTop,
      followupTop: !!followupBtnTop,
      log: !!logBtn,
    });

    // 绑定视力记录按钮（inline版本）
    if (visionBtn) {
      visionBtn.removeEventListener("click", handleVisionClick);
      visionBtn.addEventListener("click", handleVisionClick);
      console.log("✅ 视力记录按钮事件已绑定 (inline)");
    } else {
      console.error("❌ 未找到视力记录按钮 #btn-vision-record-inline");
    }

    // 绑定干预记录按钮（inline版本）
    if (interventionBtn) {
      interventionBtn.removeEventListener("click", handleInterventionClick);
      interventionBtn.addEventListener("click", handleInterventionClick);
      console.log("✅ 干预记录按钮事件已绑定 (inline)");
    } else {
      console.error("❌ 未找到干预记录按钮 #btn-intervention-record-inline");
    }

    // 绑定随访记录按钮（inline版本）
    if (followupBtn) {
      followupBtn.removeEventListener("click", handleFollowupClick);
      followupBtn.addEventListener("click", handleFollowupClick);
      console.log("✅ 随访记录按钮事件已绑定 (inline)");
    } else {
      console.error("❌ 未找到随访记录按钮 #btn-followup-record-inline");
    }

    // 绑定顶部快捷按钮
    if (visionBtnTop) {
      visionBtnTop.removeEventListener("click", handleVisionClick);
      visionBtnTop.addEventListener("click", handleVisionClick);
      console.log("✅ 视力记录按钮事件已绑定 (top)");
    }

    if (interventionBtnTop) {
      interventionBtnTop.removeEventListener("click", handleInterventionClick);
      interventionBtnTop.addEventListener("click", handleInterventionClick);
      console.log("✅ 干预记录按钮事件已绑定 (top)");
    }

    if (followupBtnTop) {
      followupBtnTop.removeEventListener("click", handleFollowupClick);
      followupBtnTop.addEventListener("click", handleFollowupClick);
      console.log("✅ 随访记录按钮事件已绑定 (top)");
    }

    // 绑定日志记录按钮
    if (logBtn) {
      logBtn.removeEventListener("click", handleLogClick);
      logBtn.addEventListener("click", handleLogClick);
      console.log("✅ 日志记录按钮事件已绑定");
    } else {
      console.error("❌ 未找到日志记录按钮 #btn-student-log");
    }
  }

  // 修复：新增按钮绑定验证功能，使用正确的按钮ID
  function verifyButtonBinding() {
    console.log("=== 验证按钮绑定结果 ===");

    const studentDetail = document.getElementById("student-detail");
    if (!studentDetail) return;

    const buttons = [
      { id: "btn-vision-record", name: "视力录入（顶部）" },
      { id: "btn-intervention-record", name: "干预录入（顶部）" },
      { id: "btn-followup-record", name: "随访录入（顶部）" },
      { id: "btn-vision-record-inline", name: "管理视力记录（inline）" },
      { id: "btn-intervention-record-inline", name: "管理干预记录（inline）" },
      { id: "btn-followup-record-inline", name: "管理随访记录（inline）" },
    ];

    buttons.forEach((btn) => {
      const element = studentDetail.querySelector("#" + btn.id);
      if (element) {
        console.log(`✅ ${btn.name} - 按钮存在且可点击`);
        // 添加视觉反馈
        element.style.border = "2px solid #28a745";
        setTimeout(() => {
          element.style.border = "";
        }, 2000);
      } else {
        console.error(`❌ ${btn.name} - 按钮不存在`);
      }
    });

    console.log("验证完成 - 绿色边框的按钮已正确绑定事件");
  }

  // 修复：定义缺失的 backToList 函数
  function backToList() {
    console.log("返回学生列表");
    document.getElementById("student-detail").style.display = "none";
    document.getElementById("search-results").style.display = "block";
    document.getElementById("pagination-bar").style.display = "block";
    selectedStudent = null;
    isNewRecord = false;
    currentMode = "readonly";
  }

  // 修复：增强测试函数，使用正确的按钮ID
  function testVisionButton() {
    console.log("=== 测试视力记录按钮 ===");
    const studentDetail = document.getElementById("student-detail");

    // 测试inline版本按钮
    const visionBtnInline = studentDetail
      ? studentDetail.querySelector("#btn-vision-record-inline")
      : null;
    console.log("inline按钮查找结果:", visionBtnInline);

    // 测试顶部版本按钮
    const visionBtnTop = studentDetail
      ? studentDetail.querySelector("#btn-vision-record")
      : null;
    console.log("顶部按钮查找结果:", visionBtnTop);

    if (visionBtnInline) {
      console.log("点击inline按钮...");
      visionBtnInline.click();
    } else if (visionBtnTop) {
      console.log("点击顶部按钮...");
      visionBtnTop.click();
    } else {
      console.error("所有视力按钮都不存在");
    }
  }

  function testInterventionButton() {
    console.log("=== 测试干预记录按钮 ===");
    const studentDetail = document.getElementById("student-detail");

    const interventionBtnInline = studentDetail
      ? studentDetail.querySelector("#btn-intervention-record-inline")
      : null;
    const interventionBtnTop = studentDetail
      ? studentDetail.querySelector("#btn-intervention-record")
      : null;

    console.log("按钮查找结果:", {
      inline: !!interventionBtnInline,
      top: !!interventionBtnTop,
    });

    if (interventionBtnInline) {
      console.log("点击inline按钮...");
      interventionBtnInline.click();
    } else if (interventionBtnTop) {
      console.log("点击顶部按钮...");
      interventionBtnTop.click();
    } else {
      console.error("所有干预按钮都不存在");
    }
  }

  function testFollowupButton() {
    console.log("=== 浇试随访记录按钮 ===");
    const studentDetail = document.getElementById("student-detail");

    const followupBtnInline = studentDetail
      ? studentDetail.querySelector("#btn-followup-record-inline")
      : null;
    const followupBtnTop = studentDetail
      ? studentDetail.querySelector("#btn-followup-record")
      : null;

    console.log("按钮查找结果:", {
      inline: !!followupBtnInline,
      top: !!followupBtnTop,
    });

    if (followupBtnInline) {
      console.log("点击inline按钮...");
      followupBtnInline.click();
    } else if (followupBtnTop) {
      console.log("点击顶部按钮...");
      followupBtnTop.click();
    } else {
      console.error("所有随访按钮都不存在");
    }
  }
  // **关键修复：确保全局函数正确暴露到window对象**
  window.viewStudentRecord = viewStudentRecord;
  window.createNewRecord = createNewRecord;
  window.queryStudents = queryStudents;
  window.renderStudentTableWithComponent = renderStudentTableWithComponent;
  window.renderPagination = renderPagination;
  window.testVisionButton = testVisionButton;
  window.testInterventionButton = testInterventionButton;
  window.testFollowupButton = testFollowupButton;
  window.checkButtonsExist = checkButtonsExist;
  window.bindJumpButtons = bindJumpButtons;
  window.verifyButtonBinding = verifyButtonBinding;
  window.testFormGeneration = function () {
    console.log("=== 手动测试表单生成 ===");
    generateMainForm()
      .then(() => {
        console.log("✅ 手动表单生成完成");
      })
      .catch((error) => {
        console.error("❌ 手动表单生成失败:", error);
      });
  };

  // 修复：页面加载完成后立即暴露函数
  console.log("全局函数已暴露到window对象");
  console.log("可用的全局函数:", {
    viewStudentRecord: typeof window.viewStudentRecord,
    createNewRecord: typeof window.createNewRecord,
    queryStudents: typeof window.queryStudents,
    testVisionButton: typeof window.testVisionButton,
    testFormGeneration: typeof window.testFormGeneration,
  });

  // 自动根据URL参数打开学生详情
  const urlParams = new URLSearchParams(window.location.search);
  const studentId = urlParams.get("student_id");
  if (studentId) {
    viewStudentRecord(studentId);
  }
  // 在页面加载完成后执行初始化
  bindSectionToggle();

  // 🔧 学生档案日志功能实现
  function bindStudentLogButtons() {
    document.querySelectorAll(".btn-log-student").forEach((btn) => {
      btn.addEventListener("click", function () {
        const studentId = btn.dataset.id;
        showStudentLogs(studentId);
      });
    });
  }

  function showStudentLogs(studentId) {
    console.log("查看学生档案日志:", studentId);
    
    fetch(`/api/students/complete/${studentId}/logs?limit=50`)
      .then((res) => res.json())
      .then((data) => {
        if (data.success && data.logs.length > 0) {
          let html = data.logs
            .map((log) => {
              let localTime = log.operation_time
                ? new Date(log.operation_time).toLocaleString()
                : "";
              let restoreButton = "";

              const actionLower = log.action.toLowerCase();
              if (actionLower === "delete") {
                restoreButton = `<button class="btn btn-sm btn-outline-success mt-2" onclick="restoreDeletedStudent(${log.id})">恢复已删除档案</button>`;
              } else if (actionLower === "restore") {
                restoreButton = `<span class="badge bg-info mt-2">恢复操作记录</span>`;
              } else if (log.old_content && (actionLower === "create" || actionLower === "update")) {
                restoreButton = `<button class="btn btn-sm btn-outline-primary mt-2" onclick="restoreStudentLog(${log.id})">恢复此版本</button>`;
              }

              let operationDesc = log.operation_desc || `${log.action}操作`;
              
              return `<div style="border-bottom:1px solid #eee;margin-bottom:12px;padding-bottom:8px;">
                <div><strong>学生ID：</strong>${studentId} | <strong>操作类型：</strong>${log.action} | <strong>操作人：</strong>${log.operator || "系统"} | <strong>时间：</strong>${localTime}</div>
                <div><strong>操作描述：</strong>${operationDesc}</div>
                ${log.new_content ? `<div><strong>当前内容：</strong><pre style="white-space:pre-wrap;font-size:12px;max-height:120px;overflow-y:auto;background:#e8f5e8;padding:8px;border-radius:4px;border-left:4px solid #28a745;">${log.new_content}</pre></div>` : ""}
                ${log.old_content ? `<div><strong>历史内容：</strong><pre style="white-space:pre-wrap;font-size:12px;max-height:120px;overflow-y:auto;background:#fff3cd;padding:8px;border-radius:4px;border-left:4px solid #ffc107;">${log.old_content}</pre>${restoreButton ? `<div style="margin-top:8px;">${restoreButton}</div>` : ""}</div>` : ""}
                </div>`;
            })
            .join("");

          if (window.Swal) {
            Swal.fire({
              title: `${data.student_name || "该学生"}的档案操作日志`,
              html: `<div style="max-height:600px;overflow-y:auto;text-align:left;">${html}</div>`,
              width: 1200,
              showConfirmButton: false,
              showCloseButton: true,
            });
          } else {
            alert("日志功能需要引入 SweetAlert2 支持美观弹窗。");
          }
        } else {
          if (window.Swal) {
            Swal.fire("无日志", "该学生暂无档案操作日志", "info");
          } else {
            alert("该学生暂无档案操作日志");
          }
        }
      })
      .catch((err) => {
        console.error("获取学生档案日志失败:", err);
        if (window.Swal) {
          Swal.fire("获取日志失败", "网络错误：" + err.message, "error");
        } else {
          alert("获取日志失败：" + err.message);
        }
      });
  }

  // 恢复已删除的学生档案
  function restoreDeletedStudent(logId) {
    if (window.Swal) {
      Swal.fire({
        title: "确认恢复",
        text: "确定要恢复这个已删除的学生档案吗？",
        icon: "question",
        showCancelButton: true,
        confirmButtonText: "确认恢复",
        cancelButtonText: "取消"
      }).then((result) => {
        if (result.isConfirmed) {
          performStudentRestore(logId, "恢复已删除的学生档案");
        }
      });
    } else {
      if (confirm("确定要恢复这个已删除的学生档案吗？")) {
        performStudentRestore(logId, "恢复已删除的学生档案");
      }
    }
  }

  // 恢复学生档案到历史版本
  function restoreStudentLog(logId) {
    if (window.Swal) {
      Swal.fire({
        title: "确认恢复",
        text: "确定要将学生档案恢复到这个历史版本吗？当前数据将被覆盖。",
        icon: "warning",
        showCancelButton: true,
        confirmButtonText: "确认恢复",
        cancelButtonText: "取消"
      }).then((result) => {
        if (result.isConfirmed) {
          performStudentRestore(logId, "恢复学生档案到历史版本");
        }
      });
    } else {
      if (confirm("确定要将学生档案恢复到这个历史版本吗？当前数据将被覆盖。")) {
        performStudentRestore(logId, "恢复学生档案到历史版本");
      }
    }
  }

  // 执行学生档案恢复操作
  function performStudentRestore(logId, operationType) {
    fetch(`/api/students/complete/logs/${logId}/restore`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        operator: '系统管理员',
        operation_type: operationType
      })
    })
    .then(response => response.json())
    .then(data => {
      if (data.success) {
        if (window.Swal) {
          Swal.fire("恢复成功", data.message || "学生档案已成功恢复", "success").then(() => {
            refreshQueryResults(); // 🔧 修改：使用刷新查询而不是页面重载
          });
        } else {
          alert("恢复成功：" + (data.message || "学生档案已成功恢复"));
          refreshQueryResults(); // 🔧 修改：使用刷新查询而不是页面重载
        }
      } else {
        console.error("恢复失败:", data.error);
        if (window.Swal) {
          Swal.fire("恢复失败", data.error || "恢复操作失败，请重试", "error");
        } else {
          alert("恢复失败：" + (data.error || "恢复操作失败，请重试"));
        }
      }
    })
    .catch(error => {
      console.error("恢复请求异常:", error);
      if (window.Swal) {
        Swal.fire("恢复失败", "恢复请求异常：" + error.message, "error");
      } else {
        alert("恢复失败：" + error.message);
      }
    });
  }

  // 🔧 将日志恢复函数暴露到全局作用域，供onclick事件使用
  window.restoreDeletedStudent = restoreDeletedStudent;
  window.restoreStudentLog = restoreStudentLog;
  window.performStudentRestore = performStudentRestore;
  window.refreshQueryResults = refreshQueryResults; // 🔧 暴露刷新查询函数

  console.log("✅ 学生档案日志恢复函数已暴露到全局作用域");
});
